import apiConfig from '../config/api.json'
import billingService from './billing.js'
import { ElMessage } from 'element-plus'
import { apiConfigApi } from './apiConfigApi.js'
import apiClient from './apiClient.js'

class APIService {
  constructor() {
    this.config = { ...apiConfig.openai }
    this.proxyConfig = apiConfig.proxy
    this.currentApiConfig = null
    // 尝试从后端加载用户配置
    this.loadUserConfig()
  }
  
  // 加载用户配置
  async loadUserConfig() {
    try {
      // 首先尝试从后端获取默认配置
      await this.loadDefaultConfigFromBackend()

      // 如果后端没有配置，回退到本地配置（向后兼容）
      if (!this.currentApiConfig) {
        this.loadLocalConfig()
      }
    } catch (error) {
      console.error('加载用户API配置失败:', error)
      // 如果后端请求失败，回退到本地配置
      this.loadLocalConfig()
    }
  }

  // 从后端加载公共配置
  async loadDefaultConfigFromBackend() {
    try {
      // 检查是否有token，如果没有token就不调用后端API
      const token = localStorage.getItem('token')
      if (!token) {
        console.log('未登录，跳过后端配置加载')
        return
      }

      // 获取公共API配置列表，使用第一个启用的配置
      const configs = await apiConfigApi.getPublicApiConfigs()
      if (configs && configs.length > 0) {
        const firstConfig = configs[0]
        this.currentApiConfig = firstConfig
        this.applyConfig(firstConfig)
      }
    } catch (error) {
      // 对于403/401错误，说明未认证，这是正常的
      if (error.response?.status === 403 || error.response?.status === 401) {
        console.log('用户未登录，使用本地配置')
      } else {
        console.log('后端暂无配置，使用本地配置')
      }
      // 不抛出错误，让调用方处理回退逻辑
    }
  }

  // 从本地存储加载配置（向后兼容）
  loadLocalConfig() {
    try {
      const configType = localStorage.getItem('apiConfigType') || 'custom'
      let userConfig = null

      if (configType === 'official') {
        const saved = localStorage.getItem('officialApiConfig')
        if (saved) {
          userConfig = JSON.parse(saved)
        }
      } else {
        const saved = localStorage.getItem('customApiConfig')
        if (saved) {
          userConfig = JSON.parse(saved)
        }
      }

      // 如果新配置不存在，尝试加载旧的配置
      if (!userConfig) {
        const oldSaved = localStorage.getItem('apiConfig')
        if (oldSaved) {
          userConfig = JSON.parse(oldSaved)
        }
      }

      if (userConfig) {
        this.config = { ...this.config, ...userConfig }
      }
    } catch (error) {
      console.error('加载本地API配置失败:', error)
    }
  }

  // 应用配置到当前实例
  applyConfig(apiConfig) {
    this.config = {
      ...this.config,
      apiKey: apiConfig.apiKey,
      baseURL: apiConfig.baseUrl,
      selectedModel: apiConfig.selectedModel,
      maxTokens: apiConfig.unlimitedTokens ? null : apiConfig.maxTokens,
      temperature: parseFloat(apiConfig.temperature) || 0.7,
      topP: parseFloat(apiConfig.topP) || 1.0,
      frequencyPenalty: parseFloat(apiConfig.frequencyPenalty) || 0.0,
      presencePenalty: parseFloat(apiConfig.presencePenalty) || 0.0,
      systemPrompt: apiConfig.systemPrompt || this.config.systemPrompt
    }
  }

  // 获取API配置
  getConfig() {
    return this.config
  }

  // 更新API配置
  updateConfig(newConfig) {
    // 如果传入的是后端配置对象，使用applyConfig方法
    if (newConfig && typeof newConfig === 'object' && newConfig.baseUrl) {
      this.currentApiConfig = newConfig
      this.applyConfig(newConfig)
    } else {
      // 否则按原来的方式更新
      this.config = { ...this.config, ...newConfig }
    }

    // 保存到localStorage作为备份（向后兼容）
    try {
      const configType = localStorage.getItem('apiConfigType') || 'custom'

      if (configType === 'official') {
        localStorage.setItem('officialApiConfig', JSON.stringify(this.config))
      } else {
        localStorage.setItem('customApiConfig', JSON.stringify(this.config))
      }

      // 同时更新旧的配置键以保持兼容性
      localStorage.setItem('apiConfig', JSON.stringify(this.config))
    } catch (error) {
      console.error('保存API配置失败:', error)
    }
  }

  // 切换到指定的API配置
  async switchToConfig(configId) {
    try {
      const config = await apiConfigApi.getApiConfig(configId)
      if (config) {
        this.currentApiConfig = config
        this.applyConfig(config)
        return true
      }
      return false
    } catch (error) {
      console.error('切换API配置失败:', error)
      return false
    }
  }

  // 重新加载默认配置
  async reloadDefaultConfig() {
    await this.loadDefaultConfigFromBackend()
  }

  // 构建后端API URL
  buildBackendURL(endpoint) {
    // 使用 apiClient 的 baseURL 配置，保持与其他 API 服务一致
    const baseURL = apiClient.defaults.baseURL || 'http://localhost:8080/api'
    return `${baseURL}${endpoint}`
  }

  // 构建后端请求头
  buildBackendHeaders() {
    const headers = {
      'Content-Type': 'application/json'
    }
    // 添加token用于认证
    const token = localStorage.getItem('token')
    if (token) {
      headers['Authorization'] = `Bearer ${token}`
    }
    return headers
  }


  // 通用后端API请求方法
  async makeBackendRequest(endpoint, options = {}) {
    const url = this.buildBackendURL(endpoint)
    const headers = this.buildBackendHeaders()
    
    const requestOptions = {
      method: 'POST',
      headers,
      ...options
    }

    try {
      const response = await fetch(url, requestOptions)
      
      if (!response.ok) {
        const errorData = await response.json()
        throw new Error(`后端API请求失败: ${response.status} - ${errorData.message || '未知错误'}`)
      }
      
      return await response.json()
    } catch (error) {
      console.error('后端API请求错误:', error)
      throw error
    }
  }

  // 流式生成文本内容（新版本：使用后端API）
  async generateTextStream(prompt, options = {}, onChunk = null) {
    console.log('开始流式生成（通过后端API），prompt:', prompt.substring(0, 100) + '...') // 调试日志
    
    // 验证prompt参数
    if (!prompt || typeof prompt !== 'string') {
      throw new Error('无效的prompt参数')
    }
    
    // 清理prompt内容，确保JSON序列化安全
    let cleanPrompt = prompt
    try {
      // 移除控制字符和不可见字符
      cleanPrompt = prompt.replace(/[\u0000-\u001F\u007F-\u009F]/g, '')
      
      // 确保可以正常JSON序列化
      JSON.stringify({ content: cleanPrompt })
      
      console.log('Prompt清理完成，原长度:', prompt.length, '清理后长度:', cleanPrompt.length)
    } catch (cleanError) {
      console.error('Prompt清理失败:', cleanError)
      throw new Error('提示词包含无法处理的字符，请检查输入内容')
    }
    
    // 估算输入token数量（用于记录，无需检查余额）
    const estimatedInputTokens = billingService.estimateTokens(cleanPrompt)
    
    const model = options.model || this.config.selectedModel || this.config.defaultModel || 'gpt-3.5-turbo'
    const maxTokens = options.maxTokens || this.config.maxTokens || null
    const temperature = options.temperature || this.config.temperature || 0.7
    
    // 使用配置中的系统提示词，如果没有配置则使用默认提示词
    const systemPrompt = this.config.systemPrompt || '你是一个专业的小说写作助手，擅长帮助用户进行创意写作、情节构思、人物塑造等。请用友好、专业的语气回答用户的问题。'
    
    const requestBody = {
      prompt: cleanPrompt,
      systemPrompt: systemPrompt,
      model: model,
      maxTokens: maxTokens,
      temperature: temperature,
      type: options.type || 'generation'
    }

    console.log('发送到后端的请求体:', requestBody)
    
    let fullContent = ''
    
    return new Promise(async (resolve, reject) => {
      try {
        const url = this.buildBackendURL('/ai/generate-stream')
        const headers = this.buildBackendHeaders()
        
        console.log('发送流式请求到:', url)
        
        const response = await fetch(url, {
          method: 'POST',
          headers: headers,
          body: JSON.stringify(requestBody),
          signal: AbortSignal.timeout(300000) // 5分钟超时
        })

        if (!response.ok) {
          const errorText = await response.text()
          console.error('后端返回错误:', response.status, errorText)
          throw new Error(`后端返回错误: ${response.status}`)
        }
        
        // 使用 ReadableStream 处理流式数据
        const reader = response.body.getReader()
        const decoder = new TextDecoder()
        let buffer = ''
        let isProcessing = true
        
        while (isProcessing) {
          const { done, value } = await reader.read()
          
          if (done) {
            isProcessing = false
            break
          }

          // 解码数据块
          const chunk = decoder.decode(value, { stream: true })
          buffer += chunk

          // 按行分割 SSE 数据
          const lines = buffer.split('\n')
          buffer = lines.pop() || '' // 保留最后一行（可能不完整）

          // SSE 格式：每个事件块包含 id, event, data, retry 等行
          let currentEvent = null
          let currentData = null
          
          for (const line of lines) {
            const trimmedLine = line.trim()
            
            if (!trimmedLine) {
              continue
            }

            // 检查事件类型
            if (trimmedLine.startsWith('event:')) {
              currentEvent = trimmedLine.slice(6).trim()
              continue
            }

            // 处理数据行
            if (trimmedLine.startsWith('data:')) {
              currentData = trimmedLine.slice(5).trim()
              
              // 处理当前事件和数据
              if (currentData) {
                if (currentData === '[DONE]') {
                  isProcessing = false
                  break
                }

                try {
                  const parsed = JSON.parse(currentData)
                  
                  // 处理错误事件
                  if (currentEvent === 'error' || parsed.error) {
                    const errorMessage = parsed.error || currentData
                    reject(new Error(errorMessage))
                    isProcessing = false
                    return
                  }
                  
                  // 处理完成事件
                  if (currentEvent === 'done' || parsed.done) {
                    isProcessing = false
                    break
                  }
                  
                  // 处理 chunk 事件（默认或明确指定）
                  if (currentEvent === 'chunk' || !currentEvent || currentEvent === 'message') {
                    const content = parsed.chunk || parsed.data || ''
                    
                    if (content) {
                      fullContent += content
                      
                      if (onChunk) {
                        try {
                          onChunk(content, fullContent)
                        } catch (chunkError) {
                          console.error('onChunk回调错误:', chunkError)
                        }
                      }
                    }
                  }
                } catch (e) {
                  // 忽略解析错误，继续处理
                }
              }
              
              // 重置事件类型
              currentEvent = null
              currentData = null
            }
          }
        }

        // 处理剩余的缓冲数据
        if (buffer.trim()) {
          if (buffer.trim().startsWith('data:')) {
            const data = buffer.trim().slice(5).trim()
            if (data && data !== '[DONE]') {
              try {
                const parsed = JSON.parse(data)
                const content = parsed.chunk || parsed.data || ''
                if (content) {
                  fullContent += content
                  if (onChunk) {
                    onChunk(content, fullContent)
                  }
                }
              } catch (e) {
                // 忽略解析错误
              }
            }
          }
        }
        
        // 记录token使用
        const outputTokens = billingService.estimateTokens(fullContent)
        billingService.recordAPICall({
          type: options.type || 'generation',
          model: model,
          content: cleanPrompt,
          response: fullContent,
          inputTokens: estimatedInputTokens,
          outputTokens: outputTokens,
          status: 'success'
        })

        resolve(fullContent)
      } catch (error) {
        console.error('流式生成错误:', error)
        
        billingService.recordAPICall({
          type: options.type || 'generation',
          model: model,
          content: cleanPrompt,
          response: fullContent,
          inputTokens: estimatedInputTokens,
          outputTokens: billingService.estimateTokens(fullContent),
          status: 'failed'
        })

        reject(error)
      }
    })
  }

  // 生成小说大纲
  async generateOutline(theme, keywords, template) {
    const templateInfo = template ? `\n参考模板：${template.name} - ${template.description}` : ''
    const keywordList = keywords ? `\n关键词：${keywords}` : ''
    
    const prompt = `请为以下主题生成一个详细的小说大纲：
主题：${theme}${templateInfo}${keywordList}

要求：
1. 生成5-8个章节
2. 每个章节用 ### 开头，后跟章节标题
3. 每个章节下面写2-3句话描述该章节的主要内容
4. 整体结构要完整，有开头、发展、高潮、结局
5. 符合所选模板的风格特点

请直接输出大纲内容：`

    return await this.generateTextStream(prompt, {}, null)
  }

  // 流式生成小说大纲
  async generateOutlineStream(theme, keywords, template, onChunk = null) {
    const templateInfo = template ? `\n参考模板：${template.name} - ${template.description}` : ''
    const keywordList = keywords ? `\n关键词：${keywords}` : ''
    
    const prompt = `请为以下主题生成一个详细的小说大纲：
主题：${theme}${templateInfo}${keywordList}

要求：
1. 生成5-8个章节
2. 每个章节用 ### 开头，后跟章节标题
3. 每个章节下面写2-3句话描述该章节的主要内容
4. 整体结构要完整，有开头、发展、高潮、结局
5. 符合所选模板的风格特点

请直接输出大纲内容：`

    return await this.generateTextStream(prompt, {}, onChunk)
  }

  // 生成章节内容
  async generateChapterContent(chapterTitle, chapterOutline, previousContent = '', template = null, characters = [], worldSettings = [], novelInfo = {}) {
    const templateInfo = template ? `\n写作风格：${template.style}\n写作提示：${template.writingTips}` : ''
    const contextInfo = previousContent ? `\n前文内容参考：${previousContent.slice(-500)}` : ''
    
    // 构建小说基本信息
    let novelBasicInfo = ''
    if (novelInfo.title || novelInfo.genre || novelInfo.intro || novelInfo.theme) {
      novelBasicInfo += '\n\n小说基本信息：'
      if (novelInfo.title) novelBasicInfo += `\n- 小说名称：${novelInfo.title}`
      if (novelInfo.genre) novelBasicInfo += `\n- 小说类型：${novelInfo.genre}`
      if (novelInfo.theme) novelBasicInfo += `\n- 小说主题：${novelInfo.theme}`
      if (novelInfo.intro) novelBasicInfo += `\n- 小说简介：${novelInfo.intro}`
    }
    
    // 构建人物信息
    let charactersInfo = ''
    if (characters.length > 0) {
      charactersInfo = '\n\n人物设定：'
      characters.forEach(char => {
        charactersInfo += `\n- ${char.name}：${char.description}`
        if (char.traits && char.traits.length > 0) {
          charactersInfo += ` (特点：${char.traits.join('、')})`
        }
      })
    }
    
    // 构建世界观信息
    let worldInfo = ''
    if (worldSettings.length > 0) {
      worldInfo = '\n\n世界观设定：'
      worldSettings.forEach(setting => {
        worldInfo += `\n- ${setting.title}：${setting.description}`
      })
    }
    
    const prompt = `请根据以下信息生成小说章节内容：
章节标题：${chapterTitle}
章节大纲：${chapterOutline}${novelBasicInfo}${templateInfo}${contextInfo}${charactersInfo}${worldInfo}

要求：
1. 字数控制在800-1200字
2. 内容要生动有趣，符合章节大纲
3. 语言流畅，描写细腻
4. 如果有前文内容，要保持连贯性
5. 符合所选模板的风格特点
6. 充分利用提供的人物设定和世界观设定
7. 确保人物行为符合其性格特点
8. 场景描写要符合世界观设定
9. 内容要符合小说的整体类型、主题和设定
10. 保持与小说简介和整体风格的一致性

请直接输出章节内容：`

    return await this.generateTextStream(prompt, {}, null)
  }

  // AI对话功能（使用后端API）
  async chatWithAI(message, chatHistory = []) {
    console.log('开始AI对话（通过后端API）')
    
    const systemPrompt = this.config.systemPrompt || '你是一个专业的小说写作助手，擅长帮助用户进行创意写作、情节构思、人物塑造等。请用友好、专业的语气回答用户的问题。'
    
    // 构建消息列表
    const messages = [
      ...chatHistory.map(msg => ({
        role: msg.isUser ? 'user' : 'assistant',
        content: msg.content
      })),
      {
        role: 'user',
        content: message
      }
    ]

    const requestBody = {
      systemPrompt: systemPrompt,
      messages: messages,
      model: this.config.selectedModel || this.config.defaultModel || 'gpt-3.5-turbo',
      maxTokens: this.config.maxTokens,
      temperature: 0.7,
      type: 'chat'
    }

    try {
      const response = await this.makeBackendRequest('/ai/generate', {
        body: JSON.stringify(requestBody)
      })
      
      console.log('对话响应成功')
      return response.data || ''
    } catch (error) {
      console.error('AI对话失败:', error)
      throw error
    }
  }

  // 生成文章摘要
  async generateSummary(content, options = {}) {
    const { length = 'medium', type = 'keypoints' } = options
    
    let lengthInstruction = ''
    switch (length) {
      case 'short':
        lengthInstruction = '请生成50-100字的简短摘要'
        break
      case 'medium':
        lengthInstruction = '请生成100-200字的中等长度摘要'
        break
      case 'long':
        lengthInstruction = '请生成200-300字的详细摘要'
        break
    }
    
    let typeInstruction = ''
    switch (type) {
      case 'keypoints':
        typeInstruction = '重点提取文章的关键要点和核心内容'
        break
      case 'plot':
        typeInstruction = '重点概括故事情节和主要事件'
        break
      case 'character':
        typeInstruction = '重点分析人物特点和关系'
        break
      case 'theme':
        typeInstruction = '重点阐述文章的主题思想和深层含义'
        break
    }
    
    const prompt = `${lengthInstruction}，${typeInstruction}。\n\n文章内容：\n${content}`
    
    return await this.generateTextStream(prompt, {
      maxTokens: null, // 移除token限制
      temperature: 0.3
    }, null)
  }

  // 内容优化建议
  async getWritingAdvice(content) {
    const prompt = `请对以下文章内容提供写作建议：

${content}

请从以下几个方面给出具体建议：
1. 语言表达
2. 情节结构
3. 人物塑造
4. 描写技巧
5. 整体改进方向

建议：`

    return await this.generateTextStream(prompt, { maxTokens: null }, null) // 移除token限制
  }

  // 根据语料库生成个性化内容
  async generatePersonalizedContent(prompt, corpus) {
    const corpusText = corpus.map(item => item.content).join('\n\n')
    const personalizedPrompt = `参考以下写作风格和内容：

${corpusText}

现在请根据上述风格，生成以下内容：
${prompt}

要求：
1. 保持与参考内容相似的写作风格
2. 语言表达要一致
3. 内容要原创且符合要求

生成内容：`

    return await this.generateTextStream(personalizedPrompt, {}, null)
  }

  // 生成通用内容
  async generateGeneralContent(keywords, template, outline, wordLimit = 500) {
    const templateInfo = template ? `\n写作风格：${template.style}\n写作提示：${template.writingTips}` : ''
    const outlineInfo = outline ? `\n参考大纲：${outline}` : ''
    const keywordList = keywords ? `\n关键词：${keywords}` : ''
    
    const prompt = `请根据以下信息生成小说内容：${keywordList}${templateInfo}${outlineInfo}

要求：
1. 字数控制在${wordLimit}字左右
2. 内容要生动有趣，情节引人入胜
3. 语言流畅，描写细腻
4. 符合所选模板的风格特点
5. 如果有大纲，要与大纲保持一致

请直接输出小说内容：`

    return await this.generateTextStream(prompt, {}, null)
  }

  // 流式生成通用内容
  async generateGeneralContentStream(keywords, template, outline, wordLimit = 500, onChunk = null) {
    const templateInfo = template ? `\n写作风格：${template.style}\n写作提示：${template.writingTips}` : ''
    const outlineInfo = outline ? `\n参考大纲：${outline}` : ''
    const keywordList = keywords ? `\n关键词：${keywords}` : ''
    
    const prompt = `请根据以下信息生成小说内容：${keywordList}${templateInfo}${outlineInfo}

要求：
1. 字数控制在${wordLimit}字左右
2. 内容要生动有趣，情节引人入胜
3. 语言流畅，描写细腻
4. 符合所选模板的风格特点
5. 如果有大纲，要与大纲保持一致

请直接输出小说内容：`

    return await this.generateTextStream(prompt, {}, onChunk)
  }

  // 验证API密钥（由后端验证，前端无需直接验证）
  async validateAPIKey() {
    try {
      console.log('验证API配置（通过后端）')
      // 前端不再需要直接验证API密钥
      // 后端会在调用AI API时自动验证
      // 这里只是一个占位符，保持向后兼容
      return true
    } catch (error) {
      console.error('API验证出错:', error)
      return false
    }
  }

  // AI生成人物（使用后端API）
  async generateCharacter(theme, characterType = '') {
    const typeInfo = characterType ? `，角色类型：${characterType}` : ''
    
    const prompt = `请根据主题"${theme}"生成一个小说人物${typeInfo}

要求：
1. 提供人物的基本信息（姓名、年龄、职业等）
2. 详细的外貌描述
3. 性格特点和行为习惯
4. 背景故事和经历
5. 人物的特殊技能或能力
6. 与主题相关的特征

请以JSON格式返回：
{
  "name": "人物姓名",
  "age": "年龄",
  "occupation": "职业",
  "appearance": "外貌描述",
  "personality": "性格特点",
  "background": "背景故事",
  "skills": ["技能1", "技能2"],
  "traits": ["特征1", "特征2", "特征3"]
}`

    try {
      const result = await this.generateTextStream(prompt, {
        maxTokens: 1000,
        temperature: 0.7,
        type: 'character'
      }, null)
      
      return JSON.parse(result)
    } catch (error) {
      console.error('生成人物失败:', error)
      throw error
    }
  }

  // AI生成世界观设定（使用后端API）
  async generateWorldSetting(theme, settingType = '') {
    const typeInfo = settingType ? `，设定类型：${settingType}` : ''
    
    const prompt = `请根据主题"${theme}"生成一个小说世界观设定${typeInfo}

要求：
1. 设定的名称和概述
2. 详细的背景描述
3. 重要的规则或法则
4. 地理环境或空间结构
5. 历史背景或重要事件
6. 与主题相关的特色元素

请以JSON格式返回：
{
  "title": "设定名称",
  "overview": "概述",
  "description": "详细描述",
  "rules": ["规则1", "规则2"],
  "geography": "地理环境",
  "history": "历史背景",
  "features": ["特色1", "特色2"]
}`

    try {
      const result = await this.generateTextStream(prompt, {
        maxTokens: 1500,
        temperature: 0.7,
        type: 'world'
      }, null)
      
      return JSON.parse(result)
    } catch (error) {
      console.error('生成世界观设定失败:', error)
      throw error
    }
  }

  // AI文章分析（使用后端API）
  async analyzeArticle(content) {
    try {
      console.log('开始文章分析（通过后端API）')
      
      const prompt = `请对以下文章进行深度分析，并以JSON格式返回分析结果：

文章内容：
${content}

请分析以下方面：
1. 情感倾向（积极/消极/中性）
2. 文章标签（最多5个关键标签）
3. 文章分类（玄幻/都市/悬疑/科幻/历史/校园/武侠/其他）
4. 文章评分（0-100分，考虑文笔、情节、结构等）
5. 详细评价（包括优点、缺点、改进建议）

返回格式：
{
  "sentiment": "积极/消极/中性",
  "tags": ["标签1", "标签2", "标签3"],
  "category": "分类",
  "score": 85,
  "evaluation": {
    "strengths": ["优点1", "优点2"],
    "weaknesses": ["缺点1", "缺点2"],
    "suggestions": ["建议1", "建议2"]
  },
  "summary": "整体评价总结"
}`

      const systemPrompt = this.config.systemPrompt || '你是一位专业的文学评论家和编辑，擅长分析各种类型的文章。请客观、专业地分析文章，给出建设性的评价和建议。'
      
      const requestBody = {
        prompt: prompt,
        systemPrompt: systemPrompt,
        model: this.config.selectedModel || this.config.defaultModel || 'gpt-3.5-turbo',
        maxTokens: 1000,
        temperature: 0.3,
        type: 'analysis'
      }

      console.log('发送文章分析请求到后端...')
      
      const response = await this.makeBackendRequest('/ai/generate', {
        body: JSON.stringify(requestBody)
      })
      
      const analysisText = response.data || ''
      console.log('文章分析响应:', analysisText)
      
      try {
        // 尝试解析JSON响应
        const analysis = JSON.parse(analysisText)
        console.log('解析的分析结果:', analysis)
        return analysis
      } catch (parseError) {
        console.error('解析AI分析结果失败:', parseError)
        // 如果解析失败，返回基础分析结果
        return {
          sentiment: '中性',
          tags: ['AI分析'],
          category: '其他',
          score: 70,
          evaluation: {
            strengths: ['内容完整'],
            weaknesses: ['AI分析解析失败'],
            suggestions: ['请检查内容格式']
          },
          summary: 'AI分析暂时不可用，使用基础分析结果'
        }
      }
    } catch (error) {
      console.error('文章分析失败:', error)
      throw error
    }
  }
}

export default new APIService()